home *** CD-ROM | disk | FTP | other *** search
/ Aminet 5 / Aminet 5 - March 1995.iso / Aminet / dev / misc / LEDA_gene.lha / LEDA-3.1c-generic / prog / graphics / polyhedron.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-05  |  6.3 KB  |  348 lines
  1. #include <LEDA/graph.h>
  2. #include <LEDA/graph_alg.h>
  3. #include <LEDA/array.h>
  4. #include <LEDA/stream.h>
  5. #include <LEDA/array.h>
  6. #include <LEDA/window.h>
  7. #include <math.h>
  8.  
  9.  
  10.  
  11. typedef GRAPH<vector,int> polyhedron;
  12.  
  13. void rotate(float alpha1,float alpha2, vector& p)
  14. { 
  15.   // rotate 3d-point p about the origin
  16.   // by alpha2 in yz-plane and alpha1 in xy-plane
  17.  
  18.     double R  = hypot(p[1],p[2]);
  19.     double phi = asin(p[1]/R);
  20.   
  21.     if (p[2] < 0) phi = M_PI - phi;
  22.   
  23.     p[1]  = ((R != 0) ? R*sin(phi+alpha2) : 0);
  24.     p[2]  = ((R != 0) ? R*cos(phi+alpha2) : 0);
  25.  
  26.     R   = hypot(p[0],p[2]);
  27.     phi = asin(p[0]/R);
  28.  
  29.     if (p[2] < 0) phi = M_PI - phi;
  30.   
  31.     p[0]  = ((R != 0) ? R*sin(phi+alpha1) : 0);
  32.     p[2]  = ((R != 0) ? R*cos(phi+alpha1) : 0);
  33. }
  34.  
  35.  
  36. point project(vector p)   // project p into xy-plane
  37. {
  38.   return point(p[0],p[1]); 
  39.  }
  40.  
  41.  
  42.  
  43. void draw_poly(window& W, polyhedron& poly, vector& trans)
  44. { node v,w;
  45.   node_array<bool> marked(poly,false);
  46.   forall_nodes(v,poly) 
  47.   { forall_adj_nodes(w,v)
  48.       if (!marked[w])
  49.       { point a = project(poly[v]+trans);
  50.         point b = project(poly[w]+trans);
  51.         W.draw_segment(a,b,blue);
  52.        }
  53.     marked[v] = true;
  54.    }
  55.  }
  56.  
  57. /*
  58. void draw_poly(window& W, polyhedron& poly, vector& trans)
  59. { edge e;
  60.   forall_edges(e,poly) 
  61.   { point a = project(poly[source(e)]+trans);
  62.     point b = project(poly[target(e)]+trans);
  63.     W.draw_segment(a,b,blue);
  64.    }
  65.  }
  66. */
  67.  
  68.  
  69. void make_poly(polyhedron& poly, int N)
  70. { 
  71.   
  72.     node* L = new node[N];
  73.     node* R = new node[N];
  74.   
  75.     float d = 2*M_PI/N;
  76.  
  77.     node v;
  78.  
  79.     poly.clear();
  80.   
  81.     for(int i=0; i<N; i++)
  82.     { point origin(0,0);
  83.       point p = origin.translate(i*d,100);
  84.       L[i] = poly.new_node(vector(p.xcoord(),p.ycoord(), 120));
  85.       R[i] = poly.new_node(vector(p.xcoord(),p.ycoord(),-120));
  86.      }
  87.  
  88.     node v0 = poly.new_node(vector(0,0,-30));
  89.   
  90.     for(i=1; i<N; i++)
  91.     { poly.new_edge(L[i],L[i-1]);
  92.       poly.new_edge(L[i-1],L[i]);
  93.       poly.new_edge(R[i],R[i-1]);
  94.       poly.new_edge(R[i-1],R[i]);
  95.       poly.new_edge(L[i],R[i]);
  96.       poly.new_edge(R[i],L[i]);
  97.       poly.new_edge(v0,R[i]);
  98.       poly.new_edge(R[i],v0);
  99.      }
  100.   
  101.     poly.new_edge(L[0],L[N-1]);
  102.     poly.new_edge(L[N-1],L[0]);
  103.     poly.new_edge(R[0],R[N-1]);
  104.     poly.new_edge(R[N-1],R[0]);
  105.     poly.new_edge(L[0],R[0]);
  106.     poly.new_edge(R[0],L[0]);
  107.     poly.new_edge(v0,R[0]);
  108.     poly.new_edge(R[0],v0);
  109.  
  110.     if (!PLANAR(poly,true)) error_handler(1,"graph not planar !");
  111.  
  112.     // compute an interior point M and move the origin to this point
  113.   
  114.     vector M(3);
  115.   
  116.     forall_nodes(v,poly)
  117.     {  M[0] += poly[v][0];
  118.        M[1] += poly[v][1];
  119.        M[2] += poly[v][2];
  120.      }
  121.   
  122.   
  123.     M[0] /= poly.number_of_nodes();
  124.     M[1] /= poly.number_of_nodes();
  125.     M[2] /= poly.number_of_nodes();
  126.   
  127.   
  128.     forall_nodes(v,poly)
  129.     { poly[v][0] -= M[0];
  130.       poly[v][1] -= M[1];
  131.       poly[v][2] -= M[2];
  132.      }
  133.   
  134. }
  135.  
  136.  
  137.  
  138. void make_sphere(GRAPH<vector,int>& G, int n)
  139. {
  140.   int m = 2*n;
  141.  
  142.   array<node>  V(m);
  143.  
  144.   node north = G.new_node(vector(0,0, 1));
  145.  
  146.   int i;
  147.   int j;
  148.   double phi1 = 0;
  149.   double phi2 = 0;
  150.   double d1 = M_PI/n;
  151.   double d2 = M_PI/n;
  152.  
  153.   for(i=0; i<m; i++) V[i] = north;
  154.  
  155.   for(phi1=d1, j=1; j<n; phi1+=d1, j++)
  156.   { double z = cos(phi1);
  157.     double r = sin(phi1);
  158.  
  159.     for(phi2=0, i=0; i<m; phi2+=d2, i++)
  160.     {
  161.       double x = r*cos(phi2);
  162.       double y = r*sin(phi2);
  163.  
  164.       node v = G.new_node(vector(x,y,z));
  165.  
  166.       if(i==0) 
  167.       { G.new_edge(v,V[i]);
  168.         G.new_edge(V[i],v);
  169.         if (j > 1)  
  170.         { G.new_edge(V[0],V[m-1]);
  171.           G.new_edge(V[m-1],V[0]);
  172.          }
  173.        }
  174.       else
  175.        { G.new_edge(v,V[i-1]);
  176.          G.new_edge(V[i-1],v);
  177.          G.new_edge(v,V[i]);
  178.          G.new_edge(V[i],v);
  179.         }
  180.       V[i] = v;
  181.      }
  182.  
  183.    }
  184.  
  185.   node south = G.new_node(vector(0,0,-1));
  186.  
  187.   G.new_edge(V[m-1],V[0]);
  188.   G.new_edge(V[0],V[m-1]);
  189.  
  190.   for (i=0;i<m;i++) 
  191.   { G.new_edge(south,V[i]);
  192.     G.new_edge(V[i],south);
  193.    }
  194.  
  195.  
  196.   node v;
  197.  
  198.   forall_nodes(v,G) G[v] = G[v]*100;
  199.  
  200.   if (!PLANAR(G,true)) error_handler(1," G not planar !");
  201.  
  202. }
  203.  
  204.  
  205.  
  206.  
  207.  
  208. void read_poly(polyhedron& poly, string fname)
  209. {
  210.   poly.clear();
  211.  
  212.   file_istream IN(fname);
  213.  
  214.   int N;
  215.   int i;
  216.  
  217.   IN >> N;
  218.  
  219.  
  220.   array<node> V(N);
  221.  
  222.   vector v(3);
  223.  
  224.   for(i = 0; i<N; i++) 
  225.   { IN >> v;
  226.     V[i] = poly.new_node(v);
  227.    }
  228.  
  229. /*
  230.   for(i = 0; i<N; i++) 
  231.   { int d;
  232.     IN >> d;
  233.     while(d--)
  234.     { IN >> j;
  235.       poly.new_edge(V[i], V[j])
  236.      }
  237.    }
  238. */
  239.  
  240.   for(i = 0; i<N; i++) 
  241.   { int u,v,w;
  242.     IN >> u >> v >> w;
  243.     poly.new_edge(V[u], V[v]);
  244.     poly.new_edge(V[v], V[w]);
  245.     poly.new_edge(V[w], V[u]);
  246.   }
  247.  
  248. }
  249.  
  250.  
  251.  
  252.  
  253. main()
  254. { 
  255.   window W(700,700);
  256.  
  257.   W.init(-250,250,-250);
  258.   W.set_node_width(4);
  259.   W.set_mode(xor_mode);
  260.  
  261.   node v;
  262.  
  263.   int     N = 5;
  264.   int speed = 40;
  265.   bool  ran = false;
  266.  
  267.  panel P("Rotate Polyhedron");
  268.  
  269.  P.text_item("");
  270.  P.text_item("This program creates and rotates a 3-dimensional polyhedron.");
  271.  P.text_item("Direction and duration of the rotation is controled by the");
  272.  P.text_item("left mouse button.");
  273.  P.text_item("");
  274.  P.bool_item("random",ran);
  275.  P.int_item("speed",speed,1,80);
  276.  P.int_item("# vertices",N,3,32);
  277.  
  278.  
  279.  
  280.  for(;;)
  281.  {
  282.     P.open(W);
  283.  
  284.     W.clear();
  285.  
  286.     // define a polyhedron in 3d space
  287.   
  288.     polyhedron poly;
  289.  
  290.     //make_poly(poly,N);
  291.     make_sphere(poly,N);
  292.   
  293.   
  294.   
  295.     forall_nodes(v,poly) rotate(1.5,0.7,poly[v]);
  296.  
  297.     W.draw_point(0,0);
  298.   
  299.   
  300.     polyhedron poly0 = poly;
  301.  
  302.     vector dir(2);   // direction and duration of rotation
  303.     //vector trans(50,50,50);  // translation
  304.     vector trans(0,0,0);  // translation
  305.     int steps;
  306.  
  307.     draw_poly(W,poly,trans);
  308.   
  309.     for(;;)
  310.     {
  311.       if (ran)
  312.       { dir[0] += random(-10000,10000)/(5000000.0);
  313.         dir[1] += random(-10000,10000)/(5000000.0);
  314.         dir = dir.norm()*(speed/500.0);
  315.         steps = 1;
  316.         if (W.get_button() != 0) break;
  317.        }
  318.       else
  319.       { int but = W.read_mouse(dir[0],dir[1]);
  320.         steps = int(dir.length()*W.scale())/8;
  321.         if (but == 3) break;
  322.         dir = dir.norm()*(speed/500.0);
  323.        }
  324.  
  325.   
  326.  
  327.       while (steps--)
  328.       {  
  329.         forall_nodes(v,poly) rotate(dir[0],dir[1],poly[v]);
  330.    
  331.         draw_poly(W,poly,trans);   // draw new position
  332.         draw_poly(W,poly0,trans);  // erase old position  (xor_mode !!)
  333.   
  334.         // poly0 = poly;
  335.   
  336.         node w = poly.first_node();
  337.         forall_nodes(v,poly0) 
  338.         { poly0[v] = poly[w];
  339.           w = poly.succ_node(w);
  340.          }
  341.       }
  342.     }
  343.  
  344.   }
  345.  
  346.  return 0;
  347. }
  348.